μ΄ ν¬κ΄μ μΈ κ°μ΄λλ₯Ό ν΅ν΄ Python NumPy λΈλ‘λμΊμ€ν μ λ§μ€ν°νμΈμ. λ°μ΄ν° κ³Όν λ° λ¨Έμ λ¬λμμ ν¨μ¨μ μΈ λ°°μ΄ νν μ‘°μμ μν κ·μΉ, κ³ κΈ κΈ°μ λ° μ€μ μ μ© λ°©λ²μ μμ보μΈμ.
NumPyμ ν λ°ν: λΈλ‘λμΊμ€ν λ° λ°°μ΄ νν μ‘°μ μ¬μΈ΅ λΆμ
Pythonμμ κ³ μ±λ₯ μμΉ μ»΄ν¨ν μ μΈκ³μ μ€μ κ²μ νμν©λλ€! λ°μ΄ν° κ³Όν, λ¨Έμ λ¬λ, κ³Όν μ°κ΅¬ λλ κΈμ΅ λΆμμ μ°Έμ¬νκ³ μλ€λ©΄ μμ¬ν μ¬μ§ μμ΄ NumPyλ₯Ό μ νμ κ²μ λλ€. NumPyλ Python κ³Όν μ»΄ν¨ν μνκ³μ κΈ°λ°μ΄λ©°, κ°λ ₯ν Nμ°¨μ λ°°μ΄ κ°μ²΄μ μ΄λ₯Ό μλνλ μ κ΅ν ν¨μ λͺ¨μμ μ 곡ν©λλ€.
μλ‘μ΄ μ¬μ©μμ μ€κ° μ¬μ©μμκ² κ°μ₯ νν μ΄λ €μ μ€ νλλ νμ€ Pythonμ κΈ°μ‘΄ 루ν κΈ°λ° μ¬κ³ λ°©μμμ ν¨μ¨μ μΈ NumPy μ½λλ₯Ό μν΄ νμν 벑ν°νλ λ°°μ΄ μ§ν₯ μ¬κ³ λ°©μμΌλ‘ μ ννλ κ²μ λλ€. μ΄λ¬ν ν¨λ¬λ€μ μ νμ ν΅μ¬μλ κ°λ ₯νλ©΄μλ μ’ μ’ μ€ν΄λλ λ©μ»€λμ¦μΈ λΈλ‘λμΊμ€ν μ΄ μμ΅λλ€. λΈλ‘λμΊμ€ν μ NumPyκ° λͺ μμ μΈ Python 루νμ μ±λ₯ μ ν μμ΄λ λ€μν λͺ¨μκ³Ό ν¬κΈ°μ λ°°μ΄μμ μλ―Έ μλ μ°μ°μ μνν μ μλλ‘ νλ "λ§λ²"μ λλ€.
μ΄ ν¬κ΄μ μΈ κ°μ΄λλ μ μΈκ³ κ°λ°μ, λ°μ΄ν° κ³Όνμ λ° λΆμκ°λ₯Ό μν΄ μ€κ³λμμ΅λλ€. λΈλ‘λμΊμ€ν μ μ²μλΆν° μμΈν μ€λͺ νκ³ , μ격ν κ·μΉμ μ΄ν΄λ³΄κ³ , λ°°μ΄ νν μ‘°μμ λ§μ€ν°νμ¬ μ μ¬λ ₯μ μ΅λν νμ©νλ λ°©λ²μ 보μ¬μ€λλ€. λ§μ§λ§μλ λΈλ‘λμΊμ€ν μ΄ *무μ*μΈμ§ μ΄ν΄ν λΏλ§ μλλΌ κΉ¨λνκ³ ν¨μ¨μ μ΄λ©° μ λ¬Έμ μΈ NumPy μ½λλ₯Ό μμ±νλ λ° *μ* μ€μνμ§ μ΄ν΄νκ² λ κ²μ λλ€.
NumPy λΈλ‘λμΊμ€ν μ΄λ 무μμ λκΉ? ν΅μ¬ κ°λ
ν΅μ¬μ μΌλ‘ λΈλ‘λμΊμ€ν μ μ°μ μ°μ° μ€μ NumPyκ° λͺ¨μμ΄ λ€λ₯Έ λ°°μ΄μ μ²λ¦¬νλ λ°©λ²μ μ€λͺ νλ κ·μΉ μ§ν©μ λλ€. μ€λ₯λ₯Ό λ°μμν€λ λμ λ μμ λ°°μ΄μ λ ν° λ°°μ΄μ λͺ¨μμ λ§κ² κ°μμΌλ‘ "λμ¬μ" μ°μ°μ μννλ νΈν κ°λ₯ν λ°©λ²μ μ°ΎμΌλ €κ³ μλν©λλ€.
λ¬Έμ : μΌμΉνμ§ μλ λ°°μ΄μ λν μ°μ°
μλ₯Ό λ€μ΄ μμ μ΄λ―Έμ§μ ν½μ κ°μ λνλ΄λ 3x3 νλ ¬μ΄ μκ³ λͺ¨λ ν½μ μ λ°κΈ°λ₯Ό 10μ© λλ¦¬λ €κ³ νλ€κ³ κ°μ ν΄ λ³΄κ² μ΅λλ€. νμ€ Pythonμμ λͺ©λ‘ λͺ©λ‘μ μ¬μ©νλ©΄ μ€μ²© 루νλ₯Ό μμ±ν μ μμ΅λλ€.
Python 루ν μ κ·Ό λ°©μ(λλ¦° λ°©λ²)
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
result = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
for i in range(len(matrix)):
for j in range(len(matrix[0])):
result[i][j] = matrix[i][j] + 10
# result will be [[11, 12, 13], [14, 15, 16], [17, 18, 19]]
μ΄ λ°©λ²μ μλνμ§λ§ μ₯ν©νκ³ , λ μ€μν κ²μ ν° λ°°μ΄μ λν΄ λ§€μ° λΉν¨μ¨μ μ λλ€. Python μΈν°ν리ν°λ 루νμ κ° λ°λ³΅μ λν΄ λμ μ€λ²ν€λλ₯Ό κ°μ΅λλ€. NumPyλ μ΄ λ³λͺ© νμμ μ κ±°νλλ‘ μ€κ³λμμ΅λλ€.
ν΄κ²°μ± : λΈλ‘λμΊμ€ν μ λ§λ²
NumPyλ₯Ό μ¬μ©νλ©΄ λμΌν μ°μ°μ΄ λ¨μμ±κ³Ό μλμ λͺ¨λΈμ΄ λ©λλ€.
NumPy λΈλ‘λμΊμ€ν μ κ·Ό λ°©μ(λΉ λ₯Έ λ°©λ²)
import numpy as np
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
result = matrix + 10
# result will be:
# array([[11, 12, 13],
# [14, 15, 16],
# [17, 18, 19]])
μ΄κ²μ΄ μ΄λ»κ² μλνμκΉμ? `matrix`μ λͺ¨μμ `(3, 3)`μ΄κ³ μ€μΉΌλΌ `10`μ λͺ¨μμ `()`μ λλ€. NumPyμ λΈλ‘λμΊμ€ν λ©μ»€λμ¦μ μ°λ¦¬μ μλλ₯Ό μ΄ν΄νμ΅λλ€. μ€μΉΌλΌ `10`μ κ°μμΌλ‘ "λ리거λ" "λΈλ‘λμΊμ€ν "νμ¬ νλ ¬μ `(3, 3)` λͺ¨μκ³Ό μΌμΉμν¨ λ€μ μμλ³ λ§μ μ μννμ΅λλ€.
κ²°μ μ μΌλ‘ μ΄ λλ¦Όμ κ°μμ λλ€. NumPyλ λ©λͺ¨λ¦¬μ 10μΌλ‘ μ±μμ§ μ 3x3 λ°°μ΄μ λ§λ€μ§ μμ΅λλ€. λ¨μΌ μ€μΉΌλΌ κ°μ μ¬μ¬μ©νμ¬ μλΉν λ©λͺ¨λ¦¬μ κ³μ° μκ°μ μ μ½νλ C μμ€ κ΅¬νμμ μνλλ λ§€μ° ν¨μ¨μ μΈ νλ‘μΈμ€μ λλ€. μ΄κ²μ΄ λΈλ‘λμΊμ€ν μ λ³Έμ§μ λλ€. μ€μ λ‘ νΈνλλλ‘ λ©λͺ¨λ¦¬ λΉμ©μ λ€μ΄μ§ μκ³ λ νΈν κ°λ₯ν κ²μ²λΌ λͺ¨μμ΄ λ€λ₯Έ λ°°μ΄μμ μ°μ°μ μννλ κ²μ λλ€.
λΈλ‘λμΊμ€ν κ·μΉ: μμΈν μμ보기
λΈλ‘λμΊμ€ν μ λ§λ²μ²λΌ λ³΄μΌ μ μμ§λ§ λ κ°μ§ κ°λ¨νκ³ μ격ν κ·μΉμ μν΄ κ΄λ¦¬λ©λλ€. λ λ°°μ΄μ λν΄ μ°μ°μ μνν λ NumPyλ μ€λ₯Έμͺ½(꼬리) μ°¨μμμ μμνμ¬ μμλ³λ‘ λͺ¨μμ λΉκ΅ν©λλ€. λΈλ‘λμΊμ€ν μ΄ μ±κ³΅νλ €λ©΄ λͺ¨λ μ°¨μ λΉκ΅μ λν΄ λ€μ λ κ°μ§ κ·μΉμ μΆ©μ‘±ν΄μΌ ν©λλ€.
κ·μΉ 1: μ°¨μ μ λ ¬
μ°¨μμ λΉκ΅νκΈ° μ μ NumPyλ 꼬리 μ°¨μμ κΈ°μ€μΌλ‘ λ λ°°μ΄μ λͺ¨μμ κ°λ μ μΌλ‘ μ λ ¬ν©λλ€. ν λ°°μ΄μ μ°¨μμ΄ λ€λ₯Έ λ°°μ΄λ³΄λ€ μ μΌλ©΄ λ ν° λ°°μ΄κ³Ό λμΌν μμ μ°¨μμ κ°μ§ λκΉμ§ ν¬κΈ°κ° 1μΈ μ°¨μμΌλ‘ μΌμͺ½μμ μ±μμ§λλ€.
μ:
- λ°°μ΄ Aμ λͺ¨μμ `(5, 4)`μ λλ€.
- λ°°μ΄ Bμ λͺ¨μμ `(4,)`μ λλ€.
NumPyλ μ΄λ₯Ό λ€μκ³Ό κ°μ΄ λΉκ΅νλ κ²μΌλ‘ λ΄ λλ€.
- Aμ λͺ¨μ: `5 x 4`
- Bμ λͺ¨μ: ` 4`
Bμ μ°¨μμ΄ λ μ κΈ° λλ¬Έμ μ΄ μ€λ₯Έμͺ½ μ λ ¬ λΉκ΅μλ μ±μμ§μ§ μμ΅λλ€. κ·Έλ¬λ `(5, 4)`μ `(5,)`λ₯Ό λΉκ΅νλ κ²½μ° μν©μ΄ λ¬λΌμ Έ μ€λ₯κ° λ°μν μ μμ΅λλ€. μ΄μ λν΄μλ λμ€μ μ΄ν΄λ³΄κ² μ΅λλ€.
κ·μΉ 2: μ°¨μ νΈνμ±
μ λ ¬ ν λΉκ΅λλ κ° μ°¨μ μ(μ€λ₯Έμͺ½μμ μΌμͺ½μΌλ‘)μ λν΄ λ€μ 쑰건 μ€ νλκ° μ°Έμ΄μ΄μΌ ν©λλ€.
- μ°¨μμ΄ κ°μ΅λλ€.
- μ°¨μ μ€ νλκ° 1μ λλ€.
μ΄λ¬ν μ‘°κ±΄μ΄ λͺ¨λ μ°¨μ μμ λν΄ μ μ§λλ©΄ λ°°μ΄μ "λΈλ‘λμΊμ€νΈ νΈν"μΌλ‘ κ°μ£Όλ©λλ€. κ²°κ³Ό λ°°μ΄μ λͺ¨μμ μ λ ₯ λ°°μ΄ μ°¨μ ν¬κΈ°μ μ΅λκ°μΈ κ° μ°¨μμ ν¬κΈ°λ₯Ό κ°μ΅λλ€.
μΈμ λ μ§ μ΄λ¬ν μ‘°κ±΄μ΄ μΆ©μ‘±λμ§ μμΌλ©΄ NumPyλ ν¬κΈ°νκ³ `"operands could not be broadcast together with shapes ..."`μ κ°μ λͺ νν λ©μμ§μ ν¨κ» `ValueError`λ₯Ό λ°μμν΅λλ€.
μ€μ μ: μλ μ€μΈ λΈλ‘λμΊμ€ν
κ°λ¨ν μλΆν° 볡μ‘ν μκΉμ§ μΌλ ¨μ μ€μ μλ‘ μ΄λ¬ν κ·μΉμ λν μ΄ν΄λ₯Ό νκ³ ν ν΄ λ³΄κ² μ΅λλ€.
μ 1: κ°μ₯ κ°λ¨ν κ²½μ° - μ€μΉΌλΌμ λ°°μ΄
μ΄κ²μ μ°λ¦¬κ° μμν μμ λλ€. κ·μΉμ κ΄μ μμ λΆμν΄ λ³΄κ² μ΅λλ€.
A = np.array([[1, 2, 3], [4, 5, 6]]) # Shape: (2, 3)
B = 10 # Shape: ()
C = A + B
λΆμ:
- λͺ¨μ: Aλ `(2, 3)`μ΄κ³ Bλ ν¨κ³Όμ μΌλ‘ μ€μΉΌλΌμ λλ€.
- κ·μΉ 1(μ λ ¬): NumPyλ μ€μΉΌλΌλ₯Ό νΈν κ°λ₯ν μ°¨μμ λ°°μ΄λ‘ μ²λ¦¬ν©λλ€. λͺ¨μμ΄ `(1, 1)`λ‘ μ±μμ§λ€κ³ μκ°ν μ μμ΅λλ€. `(2, 3)`κ³Ό `(1, 1)`μ λΉκ΅ν΄ λ³΄κ² μ΅λλ€.
- κ·μΉ 2(νΈνμ±):
- 꼬리 μ°¨μ: `3` λ `1`. 쑰건 2κ° μΆ©μ‘±λ©λλ€(νλλ 1).
- λ€μ μ°¨μ: `2` λ `1`. 쑰건 2κ° μΆ©μ‘±λ©λλ€(νλλ 1).
- κ²°κ³Ό λͺ¨μ: κ° μ°¨μ μμ μ΅λκ°μ `(max(2, 1), max(3, 1))`μ΄λ©°, μ΄λ `(2, 3)`μ λλ€. μ€μΉΌλΌ `10`μ΄ μ΄ μ 체 λͺ¨μμ κ±Έμ³ λΈλ‘λμΊμ€νΈλ©λλ€.
μ 2: 2D λ°°μ΄κ³Ό 1D λ°°μ΄(νλ ¬ λ° λ²‘ν°)
μ΄κ²μ λ°μ΄ν° νλ ¬μ κΈ°λ₯λ³ μ€νμ μ μΆκ°νλ κ²κ³Ό κ°μ΄ λ§€μ° μΌλ°μ μΈ μ¬μ© μ¬λ‘μ λλ€.
A = np.arange(12).reshape(3, 4) # Shape: (3, 4)
# A = array([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11]])
B = np.array([10, 20, 30, 40]) # Shape: (4,)
C = A + B
λΆμ:
- λͺ¨μ: Aλ `(3, 4)`μ΄κ³ Bλ `(4,)`μ λλ€.
- κ·μΉ 1(μ λ ¬): λͺ¨μμ μ€λ₯Έμͺ½μΌλ‘ μ λ ¬ν©λλ€.
- Aμ λͺ¨μ: `3 x 4`
- Bμ λͺ¨μ: ` 4`
- κ·μΉ 2(νΈνμ±):
- 꼬리 μ°¨μ: `4` λ `4`. 쑰건 1μ΄ μΆ©μ‘±λ©λλ€(κ°μ).
- λ€μ μ°¨μ: `3` λ `(μμ)`. λ μμ λ°°μ΄μ μ°¨μμ΄ μμΌλ©΄ ν΄λΉ μ°¨μμ ν¬κΈ°κ° 1μΈ κ²κ³Ό κ°μ΅λλ€. λ°λΌμ `3` λ `1`μ λΉκ΅ν©λλ€. 쑰건 2κ° μΆ©μ‘±λ©λλ€. Bμ κ°μ΄ μ΄ μ°¨μμ λ°λΌ λμ΄λκ±°λ λΈλ‘λμΊμ€νΈλ©λλ€.
- κ²°κ³Ό λͺ¨μ: κ²°κ³Ό λͺ¨μμ `(3, 4)`μ
λλ€. 1D λ°°μ΄ `B`κ° `A`μ κ° νμ ν¨κ³Όμ μΌλ‘ μΆκ°λ©λλ€.
# C will be: # array([[10, 21, 32, 43], # [14, 25, 36, 47], # [18, 29, 40, 51]])
μ 3: μ΄ λ° ν λ²‘ν° μ‘°ν©
μ΄ λ²‘ν°μ ν 벑ν°λ₯Ό κ²°ν©νλ©΄ μ΄λ»κ² λ κΉμ? μ¬κΈ°μμ λΈλ‘λμΊμ€ν μ κ°λ ₯ν μΈλΆ μ νκ³Ό κ°μ λμμ λ§λλλ€.
A = np.array([0, 10, 20]).reshape(3, 1) # Shape: (3, 1) a column vector
# A = array([[ 0],
# [10],
# [20]])
B = np.array([0, 1, 2]) # Shape: (3,). Can also be (1, 3)
# B = array([0, 1, 2])
C = A + B
λΆμ:
- λͺ¨μ: Aλ `(3, 1)`μ΄κ³ Bλ `(3,)`μ λλ€.
- κ·μΉ 1(μ λ ¬): λͺ¨μμ μ λ ¬ν©λλ€.
- Aμ λͺ¨μ: `3 x 1`
- Bμ λͺ¨μ: ` 3`
- κ·μΉ 2(νΈνμ±):
- 꼬리 μ°¨μ: `1` λ `3`. 쑰건 2κ° μΆ©μ‘±λ©λλ€(νλλ 1). λ°°μ΄ `A`κ° μ΄ μ°¨μ(μ΄)μ κ±Έμ³ λμ΄λ©λλ€.
- λ€μ μ°¨μ: `3` λ `(μμ)`. μ΄μ κ³Ό λ§μ°¬κ°μ§λ‘ `3` λ `1`λ‘ μ²λ¦¬ν©λλ€. 쑰건 2κ° μΆ©μ‘±λ©λλ€. λ°°μ΄ `B`κ° μ΄ μ°¨μ(ν)μ κ±Έμ³ λμ΄λ©λλ€.
- κ²°κ³Ό λͺ¨μ: κ° μ°¨μ μμ μ΅λκ°μ `(max(3, 1), max(1, 3))`μ΄λ©°, μ΄λ `(3, 3)`μ
λλ€. κ²°κ³Όλ μ 체 νλ ¬μ
λλ€.
# C will be: # array([[ 0, 1, 2], # [10, 11, 12], # [20, 21, 22]])
μ 4: λΈλ‘λμΊμ€ν μ€ν¨(ValueError)
λΈλ‘λμΊμ€ν μ΄ μ€ν¨νλ κ²½μ°λ₯Ό μ΄ν΄νλ κ²λ μ€μν©λλ€. 3x4 νλ ¬μ κ° μ΄μ κΈΈμ΄ 3μ 벑ν°λ₯Ό μΆκ°ν΄ λ³΄κ² μ΅λλ€.
A = np.arange(12).reshape(3, 4) # Shape: (3, 4)
B = np.array([10, 20, 30]) # Shape: (3,)
try:
C = A + B
except ValueError as e:
print(e)
μ΄ μ½λλ λ€μμ μΈμν©λλ€. operands could not be broadcast together with shapes (3,4) (3,)
λΆμ:
- λͺ¨μ: Aλ `(3, 4)`μ΄κ³ Bλ `(3,)`μ λλ€.
- κ·μΉ 1(μ λ ¬): λͺ¨μμ μ€λ₯Έμͺ½μΌλ‘ μ λ ¬ν©λλ€.
- Aμ λͺ¨μ: `3 x 4`
- Bμ λͺ¨μ: ` 3`
- κ·μΉ 2(νΈνμ±):
- 꼬리 μ°¨μ: `4` λ `3`. μ΄κ²μ μ€ν¨ν©λλ€! μ°¨μμ΄ κ°μ§ μκ³ λ λ€ 1λ μλλλ€. NumPyλ μ¦μ μ€μ§νκ³ `ValueError`λ₯Ό λ°μμν΅λλ€.
μ΄ μ€ν¨λ λ Όλ¦¬μ μ λλ€. NumPyλ ν¬κΈ°κ° 3μΈ λ²‘ν°λ₯Ό ν¬κΈ°κ° 4μΈ νμΌλ‘ μ λ ¬νλ λ°©λ²μ λͺ¨λ¦ λλ€. μ°λ¦¬μ μλλ μλ§λ *μ΄* 벑ν°λ₯Ό μΆκ°νλ κ²μ΄μμ κ²μ λλ€. κ·Έλ κ² νλ €λ©΄ λ°°μ΄ Bμ λͺ¨μμ λͺ μμ μΌλ‘ μ‘°μν΄μΌ νλ©°, μ΄λ λ€μ μ£Όμ λ‘ μ΄μ΄μ§λλ€.
λΈλ‘λμΊμ€ν μ μν λ°°μ΄ νν μ‘°μ λ§μ€ν°νκΈ°
μ’ μ’ λ°μ΄ν°κ° μννλ €λ μ°μ°μ μλ²½ν λͺ¨μμ΄ μλ μ μμ΅λλ€. NumPyλ λ°°μ΄μ μ¬κ΅¬μ±νκ³ μ‘°μνμ¬ λΈλ‘λμΊμ€νΈ νΈνμ΄ λλλ‘ νλ λ€μν λꡬλ₯Ό μ 곡ν©λλ€. μ΄κ²μ λΈλ‘λμΊμ€ν μ μ€ν¨κ° μλλΌ μ€νλ € μλμ λν΄ λͺ μμ μΌλ‘ μ§μ νλλ‘ κ°μ νλ κΈ°λ₯μ λλ€.
`np.newaxis`μ ν
λ°°μ΄μ νΈν κ°λ₯νκ² λ§λλ λ° κ°μ₯ μΌλ°μ μΈ λꡬλ `np.newaxis`μ λλ€. `np.newaxis`λ ν¬κΈ°κ° 1μΈ μ°¨μλ§νΌ κΈ°μ‘΄ λ°°μ΄μ μ°¨μμ λ리λ λ° μ¬μ©λ©λλ€. `np.newaxis`λ `None`μ λ³μΉμ΄λ―λ‘ λ κ°κ²°ν ꡬ문μ μν΄ `None`μ μ¬μ©ν μλ μμ΅λλ€.
μ΄μ μ μ€ν¨ν μλ₯Ό μμ ν΄ λ³΄κ² μ΅λλ€. μ°λ¦¬μ λͺ©νλ λ²‘ν° `B`λ₯Ό `A`μ κ° μ΄μ μΆκ°νλ κ²μ λλ€. μ¦, `B`λ `(3, 1)` λͺ¨μμ μ΄ λ²‘ν°λ‘ μ²λ¦¬λμ΄μΌ ν©λλ€.
A = np.arange(12).reshape(3, 4) # Shape: (3, 4)
B = np.array([10, 20, 30]) # Shape: (3,)
# Use newaxis to add a new dimension, turning B into a column vector
B_reshaped = B[:, np.newaxis] # Shape is now (3, 1)
# B_reshaped is now:
# array([[10],
# [20],
# [30]])
C = A + B_reshaped
μμ λΆμ:
- λͺ¨μ: Aλ `(3, 4)`μ΄κ³ B_reshapedλ `(3, 1)`μ λλ€.
- κ·μΉ 2(νΈνμ±):
- 꼬리 μ°¨μ: `4` λ `1`. OK(νλλ 1).
- λ€μ μ°¨μ: `3` λ `3`. OK(κ°μ).
- κ²°κ³Ό λͺ¨μ: `(3, 4)`. `(3, 1)` μ΄ λ²‘ν°κ° Aμ 4κ° μ΄μ κ±Έμ³ λΈλ‘λμΊμ€νΈλ©λλ€.
# C will be: # array([[10, 11, 12, 13], # [24, 25, 26, 27], # [38, 39, 40, 41]])
`[:, np.newaxis]` ꡬ문μ 1D λ°°μ΄μ μ΄ λ²‘ν°λ‘ λ³ννλ NumPyμ νμ€μ μ΄κ³ λ§€μ° μ½κΈ° μ¬μ΄ κ΄μ©κ΅¬μ λλ€.
`reshape()` λ©μλ
λ°°μ΄μ λͺ¨μμ λ³κ²½νλ λ° λ μΌλ°μ μΈ λꡬλ `reshape()` λ©μλμ λλ€. μ΄ μμ μκ° λμΌνκ² μ μ§λλ ν μ λͺ¨μμ μ 체μ μΌλ‘ μ§μ ν μ μμ΅λλ€.
`reshape`λ₯Ό μ¬μ©νμ¬ μμ λμΌν κ²°κ³Όλ₯Ό μ»μ μ μμ΅λλ€.
B_reshaped = B.reshape(3, 1) # Same as B[:, np.newaxis]
`reshape()` λ©μλλ νΉν λ°°μ΄μ μ΄ ν¬κΈ°μ λ€λ₯Έ μ§μ λ μ°¨μμ κΈ°λ°μΌλ‘ ν΄λΉ μ°¨μμ ν¬κΈ°λ₯Ό μλμΌλ‘ κ³μ°νλλ‘ NumPyμ μ§μνλ νΉμ `-1` μΈμλ₯Ό μ¬μ©νμ¬ λ§€μ° κ°λ ₯ν©λλ€.
x = np.arange(12)
# Reshape to 4 rows, and automatically figure out the number of columns
x_reshaped = x.reshape(4, -1) # Shape will be (4, 3)
`.T`λ‘ μ μΉ
λ°°μ΄μ μ μΉνλ©΄ μΆμ΄ λ°λλλ€. 2D λ°°μ΄μ κ²½μ° νκ³Ό μ΄μ λ€μ§μ΅λλ€. μ΄κ²μ λΈλ‘λμΊμ€ν μ°μ° μ μ λͺ¨μμ μ λ ¬νλ λ° μ μ©ν λ λ€λ₯Έ λκ΅¬κ° λ μ μμ΅λλ€.
A = np.arange(12).reshape(3, 4) # Shape: (3, 4)
A_transposed = A.T # Shape: (4, 3)
νΉμ λΈλ‘λμΊμ€ν μ€λ₯λ₯Ό μμ νλ λ° λ μ§μ μ μ΄μ§λ§ μ μΉ μ΄ν΄λ λΈλ‘λμΊμ€ν μ°μ°λ³΄λ€ λ¨Όμ λ°μνλ μΌλ°μ μΈ νλ ¬ μ‘°μμ λ§€μ° μ€μν©λλ€.
κ³ κΈ λΈλ‘λμΊμ€ν μμ© νλ‘κ·Έλ¨ λ° μ¬μ© μ¬λ‘
μ΄μ κ·μΉκ³Ό λꡬλ₯Ό νμ€ν μ΄ν΄νμΌλ―λ‘ λΈλ‘λμΊμ€ν μ΄ μ°μνκ³ ν¨μ¨μ μΈ μ루μ μ κ°λ₯νκ² νλ λͺ κ°μ§ μ€μ μλ리μ€λ₯Ό μ΄ν΄λ³΄κ² μ΅λλ€.
1. λ°μ΄ν° μ κ·ν(νμ€ν)
λ¨Έμ λ¬λμ κΈ°λ³Έ μ μ²λ¦¬ λ¨κ³λ μΌλ°μ μΌλ‘ νκ· μ λΉΌκ³ νμ€ νΈμ°¨(Z-μ μ μ κ·ν)λ‘ λλμ΄ νΉμ§μ νμ€ννλ κ²μ λλ€. λΈλ‘λμΊμ€ν μ μ΄λ₯Ό λ§€μ° κ°λ¨νκ² λ§λλλ€.
1,000κ°μ μνκ³Ό 5κ°μ νΉμ§μ΄ μλ λ°μ΄ν° μΈνΈ `X`κ° μλ€κ³ μμν΄ λ³΄μΈμ. λͺ¨μμ `(1000, 5)`μ λλ€.
# Generate some sample data
np.random.seed(0)
X = np.random.rand(1000, 5) * 100
# Calculate the mean and standard deviation for each feature (column)
# axis=0 means we perform the operation along the columns
mean = X.mean(axis=0) # Shape: (5,)
std = X.std(axis=0) # Shape: (5,)
# Now, normalize the data using broadcasting
X_normalized = (X - mean) / std
λΆμ:
- `X - mean`μμ `(1000, 5)`μ `(5,)` λͺ¨μμμ μ°μ°μ μνν©λλ€.
- μ΄κ²μ μ 2μ μ νν κ°μ΅λλ€. `(5,)` λͺ¨μμ `mean` 벑ν°λ `X`μ λͺ¨λ 1000κ° νμ ν΅ν΄ λΈλ‘λμΊμ€νΈλ©λλ€.
- `std`λ‘ λλλ κ²μλ λμΌν λΈλ‘λμΊμ€ν μ΄ λ°μν©λλ€.
λΈλ‘λμΊμ€ν μ΄ μμΌλ©΄ 루νλ₯Ό μμ±ν΄μΌ νλ©°, μ΄λ ν¨μ¬ λλ¦¬κ³ μ₯ν©ν©λλ€.
2. νλ‘ν λ° κ³μ°μ μν 그리λ μμ±
ννΈλ§΅ λλ μ€κ³½μ νλ‘―μ λ§λλ κ²κ³Ό κ°μ΄ 2D μ 그리λμμ ν¨μλ₯Ό νκ°νλ €λ κ²½μ° λΈλ‘λμΊμ€ν μ μλ²½ν λꡬμ λλ€. `np.meshgrid`κ° μ’ μ’ μ΄μ μ¬μ©λμ§λ§ κΈ°λ³Έ λΈλ‘λμΊμ€ν λ©μ»€λμ¦μ μ΄ν΄νκΈ° μν΄ λμΌν κ²°κ³Όλ₯Ό μλμΌλ‘ μ»μ μ μμ΅λλ€.
# Create 1D arrays for x and y axes
x = np.linspace(-5, 5, 11) # Shape (11,)
y = np.linspace(-4, 4, 9) # Shape (9,)
# Use newaxis to prepare them for broadcasting
x_grid = x[np.newaxis, :] # Shape (1, 11)
y_grid = y[:, np.newaxis] # Shape (9, 1)
# A function to evaluate, e.g., f(x, y) = x^2 + y^2
# Broadcasting creates the full 2D result grid
z = x_grid**2 + y_grid**2 # Resulting shape: (9, 11)
λΆμ:
- `(1, 11)` λͺ¨μμ λ°°μ΄μ `(9, 1)` λͺ¨μμ λ°°μ΄μ μΆκ°ν©λλ€.
- κ·μΉμ λ°λΌ `x_grid`λ 9κ° νμΌλ‘ λΈλ‘λμΊμ€νΈλκ³ `y_grid`λ 11κ° μ΄λ‘ λΈλ‘λμΊμ€νΈλ©λλ€.
- κ²°κ³Όλ λͺ¨λ `(x, y)` μμμ νκ°λ ν¨μλ₯Ό ν¬ν¨νλ `(9, 11)` 그리λμ λλ€.
3. μλ³ κ±°λ¦¬ νλ ¬ κ³μ°
μ΄κ²μ λ κ³ κΈμ€λ½μ§λ§ λ§€μ° κ°λ ₯ν μμ λλ€. `D`μ°¨μ 곡κ°μ `N`κ° μ μ§ν©(λͺ¨μ `(N, D)`μ λ°°μ΄)μ΄ μ£Όμ΄μ‘μ λ λͺ¨λ μ μ μ¬μ΄μ 거리μ `(N, N)` νλ ¬μ ν¨μ¨μ μΌλ‘ κ³μ°νλ €λ©΄ μ΄λ»κ² ν΄μΌ ν κΉμ?
ν΅μ¬μ `np.newaxis`λ₯Ό μ¬μ©νμ¬ 3D λΈλ‘λμΊμ€ν μ°μ°μ μ€μ νλ μ리ν νΈλ¦μ λλ€.
# 5 points in a 2-dimensional space
np.random.seed(42)
points = np.random.rand(5, 2)
# Prepare the arrays for broadcasting
# Reshape points to (5, 1, 2)
P1 = points[:, np.newaxis, :]
# Reshape points to (1, 5, 2)
P2 = points[np.newaxis, :, :]
# Broadcasting P1 - P2 will have shapes:
# (5, 1, 2)
# (1, 5, 2)
# Resulting shape will be (5, 5, 2)
diff = P1 - P2
# Now calculate the squared Euclidean distance
# We sum the squares along the last axis (the D dimensions)
dist_sq = np.sum(diff**2, axis=-1)
# Get the final distance matrix by taking the square root
distances = np.sqrt(dist_sq) # Final shape: (5, 5)
μ΄ λ²‘ν°νλ μ½λλ λ κ°μ μ€μ²© 루νλ₯Ό λ체νκ³ ν¨μ¬ λ ν¨μ¨μ μ λλ€. λ°°μ΄ λͺ¨μκ³Ό λΈλ‘λμΊμ€ν μΈ‘λ©΄μμ μκ°νλ©΄ 볡μ‘ν λ¬Έμ λ₯Ό μ°μνκ² ν΄κ²°ν μ μλ€λ μ¦κ±°μ λλ€.
μ±λ₯ μλ―Έ: λΈλ‘λμΊμ€ν μ΄ μ€μν μ΄μ
λΈλ‘λμΊμ€ν κ³Ό 벑ν°νκ° Python 루νλ³΄λ€ λΉ λ₯΄λ€κ³ κ±°λ μ£Όμ₯νμ΅λλ€. κ°λ¨ν ν μ€νΈλ‘ μ΄λ₯Ό μ¦λͺ ν΄ λ³΄κ² μ΅λλ€. ν° λ°°μ΄ λ κ°λ₯Ό 루νμ NumPyλ‘ ν λ²μ© λν©λλ€.
벑ν°ν λ 루ν: μλ ν μ€νΈ
Pythonμ κΈ°λ³Έ `time` λͺ¨λμ μ¬μ©νμ¬ λ°λͺ¨λ₯Ό μνν μ μμ΅λλ€. μ€μ μλλ¦¬μ€ λλ Jupyter Notebookκ³Ό κ°μ λνν νκ²½μμλ λ μ격ν μΈ‘μ μ μν΄ `%timeit` λ§€μ§ λͺ λ Ήμ μ¬μ©ν μ μμ΅λλ€.
import time
# Create large arrays
a = np.random.rand(1000, 1000)
b = np.random.rand(1000, 1000)
# --- Method 1: Python Loop ---
start_time = time.time()
c_loop = np.zeros_like(a)
for i in range(a.shape[0]):
for j in range(a.shape[1]):
c_loop[i, j] = a[i, j] + b[i, j]
loop_duration = time.time() - start_time
# --- Method 2: NumPy Vectorization ---
start_time = time.time()
c_numpy = a + b
numpy_duration = time.time() - start_time
print(f"Python loop duration: {loop_duration:.6f} seconds")
print(f"NumPy vectorization duration: {numpy_duration:.6f} seconds")
print(f"NumPy is approximately {loop_duration / numpy_duration:.1f} times faster.")
μΌλ°μ μΈ μ»΄ν¨ν°μμ μ΄ μ½λλ₯Ό μ€ννλ©΄ NumPy λ²μ μ΄ 100~1000λ°° λ λΉ λ¦ λλ€. λ°°μ΄ ν¬κΈ°κ° μ¦κ°ν¨μ λ°λΌ μ°¨μ΄κ° λμ± λλλ¬μ§λλ€. μ΄κ²μ μ¬μν μ΅μ νκ° μλλΌ κ·Όλ³Έμ μΈ μ±λ₯ μ°¨μ΄μ λλ€.
"λ΄λΆ" μ΄μ
NumPyκ° ν¨μ¬ λ λΉ λ₯Έ μ΄μ λ 무μμΌκΉμ? κ·Έ μ΄μ λ μν€ν μ²μ μμ΅λλ€.
- μ»΄νμΌλ μ½λ: NumPy μ°μ°μ Python μΈν°ν리ν°μμ μ€νλμ§ μμ΅λλ€. μ΄λ¬ν μ°μ°μ 미리 μ»΄νμΌλκ³ κ³ λλ‘ μ΅μ νλ C λλ Fortran ν¨μμ λλ€. κ°λ¨ν `a + b`λ λΉ λ₯΄κ³ λ¨μΌν C ν¨μλ₯Ό νΈμΆν©λλ€.
- λ©λͺ¨λ¦¬ λ μ΄μμ: NumPy λ°°μ΄μ μΌκ΄λ λ°μ΄ν° μ νμ κ°μ§ λ©λͺ¨λ¦¬μ μ‘°λ°ν λ°μ΄ν° λΈλ‘μ λλ€. μ΄λ₯Ό ν΅ν΄ κΈ°λ³Έ C μ½λλ Python λͺ©λ‘κ³Ό κ΄λ ¨λ μ ν κ²μ¬ λ° κΈ°ν μ€λ²ν€λ μμ΄λ λ°λ³΅ν μ μμ΅λλ€.
- SIMD(λ¨μΌ λͺ λ Ήμ΄, λ€μ€ λ°μ΄ν°): μ΅μ CPUλ μ¬λ¬ λ°μ΄ν° μ‘°κ°μμ λμμ λμΌν μ°μ°μ μνν μ μμ΅λλ€. NumPyμ μ»΄νμΌλ μ½λλ νμ€ Python 루νμμλ λΆκ°λ₯ν μ΄λ¬ν λ²‘ν° μ²λ¦¬ κΈ°λ₯μ νμ©νλλ‘ μ€κ³λμμ΅λλ€.
λΈλ‘λμΊμ€ν μ μ΄λ¬ν λͺ¨λ μ΄μ μ μμν©λλ€. λΈλ‘λμΊμ€ν μ λ°°μ΄ λͺ¨μμ΄ μλ²½νκ² μΌμΉνμ§ μλ κ²½μ°μλ 벑ν°νλ C μ°μ°μ μ±λ₯μ μ‘μΈμ€ν μ μλλ‘ νλ μ€λ§νΈ λ μ΄μ΄μ λλ€.
μΌλ°μ μΈ ν¨μ λ° λͺ¨λ² μ¬λ‘
κ°λ ₯νμ§λ§ λΈλ‘λμΊμ€ν μλ μ£Όμκ° νμν©λλ€. λͺ μ¬ν΄μΌ ν λͺ κ°μ§ μΌλ°μ μΈ λ¬Έμ μ λͺ¨λ² μ¬λ‘λ λ€μκ³Ό κ°μ΅λλ€.
μμμ λΈλ‘λμΊμ€ν μ λ²κ·Έλ₯Ό μ¨κΈΈ μ μμ΅λλ€.
λΈλ‘λμΊμ€ν μ΄ λλ‘λ "κ·Έλ₯ μλ"ν μ μκΈ° λλ¬Έμ λ°°μ΄ λͺ¨μμ μ£Όμνμ§ μμΌλ©΄ μλνμ§ μμ κ²°κ³Όκ° λ°μν μ μμ΅λλ€. μλ₯Ό λ€μ΄ `(3,)` λ°°μ΄μ `(3, 3)` νλ ¬μ μΆκ°νλ κ²μ μλνμ§λ§ `(4,)` λ°°μ΄μ μΆκ°νλ κ²μ μ€ν¨ν©λλ€. μ€μλ‘ μλͺ»λ ν¬κΈ°μ 벑ν°λ₯Ό λ§λ€λ©΄ λΈλ‘λμΊμ€ν μ΄ λμμ΄ λμ§ μμ΅λλ€. λΈλ‘λμΊμ€ν μ μ€λ₯λ₯Ό μ ννκ² λ°μμν΅λλ€. λ λ―Έλ¬ν λ²κ·Έλ ν λ μ΄ λ²‘ν° νΌλμμ λΉλ‘―λ©λλ€.
λͺ¨μμ λͺ μμ μΌλ‘ μ§μ νμΈμ.
λ²κ·Έλ₯Ό νΌνκ³ μ½λ λͺ νμ±μ κ°μ νκΈ° μν΄ λͺ μμ μΌλ‘ μ§μ νλ κ²μ΄ μ’μ΅λλ€. μ΄ λ²‘ν°λ₯Ό μΆκ°νλ €λ κ²½μ° `reshape` λλ `np.newaxis`λ₯Ό μ¬μ©νμ¬ λͺ¨μμ `(N, 1)`λ‘ λ§λμΈμ. μ΄λ κ² νλ©΄ μ½λκ° λ€λ₯Έ μ¬λ(κ·Έλ¦¬κ³ λ―Έλμ μμ )μκ² λ μ½κΈ° μ¬μμ§κ³ NumPyμ μλκ° λͺ νν΄μ§λλ€.
λ©λͺ¨λ¦¬ κ³ λ € μ¬ν
λΈλ‘λμΊμ€ν μ체λ λ©λͺ¨λ¦¬ ν¨μ¨μ μ΄μ§λ§(μ€κ° 볡μ¬λ³Έμ΄ μμ±λμ§ μμ) μ°μ°μ κ²°κ³Όλ κ°μ₯ ν° λΈλ‘λμΊμ€νΈ λͺ¨μμ κ°μ§ μ λ°°μ΄μ΄λΌλ μ μ κΈ°μ΅νμΈμ. `(10000, 1)` λ°°μ΄μ `(1, 10000)` λ°°μ΄λ‘ λΈλ‘λμΊμ€νΈνλ©΄ κ²°κ³Όλ `(10000, 10000)` λ°°μ΄μ΄ λλ©° μλΉν μμ λ©λͺ¨λ¦¬λ₯Ό μλΉν μ μμ΅λλ€. νμ μΆλ ₯ λ°°μ΄μ λͺ¨μμ μκ³ μμ΄μΌ ν©λλ€.
λͺ¨λ² μ¬λ‘ μμ½
- κ·μΉμ μμλμΈμ: λΈλ‘λμΊμ€ν μ λ κ°μ§ κ·μΉμ λ΄λ©΄ννμΈμ. μμ¬μ€λ¬μ΄ κ²½μ° λͺ¨μμ μ μ΄ μλμΌλ‘ νμΈνμΈμ.
- λͺ¨μμ μμ£Ό νμΈνμΈμ: κ°λ° λ° λλ²κΉ μ€μ `array.shape`λ₯Ό μμ λ‘κ² μ¬μ©νμ¬ λ°°μ΄μ΄ μμν μ°¨μμ κ°λλ‘ νμΈμ.
- λͺ μμ μΌλ‘ μ§μ νμΈμ: `np.newaxis` λ° `reshape`λ₯Ό μ¬μ©νμ¬ νΉν ν λλ μ΄λ‘ ν΄μλ μ μλ 1D 벑ν°λ₯Ό μ²λ¦¬ν λ μλλ₯Ό λͺ νν νμΈμ.
- `ValueError`λ₯Ό μ λ’°νμΈμ: NumPyμμ νΌμ°μ°μλ₯Ό λΈλ‘λμΊμ€νΈν μ μλ€κ³ νμλλ©΄ κ·μΉμ΄ μλ°λμκΈ° λλ¬Έμ λλ€. μΈμ°μ§ λ§κ³ λͺ¨μμ λΆμνκ³ λ°°μ΄μ μ¬κ΅¬μ±νμ¬ μλμ μΌμΉμν€μΈμ.
κ²°λ‘
NumPy λΈλ‘λμΊμ€ν μ λ¨μν νΈμ μ΄μμ μλ―Έλ₯Ό κ°μ§λλ€. NumPy λΈλ‘λμΊμ€ν μ Pythonμμ ν¨μ¨μ μΈ μμΉ νλ‘κ·Έλλ°μ μ΄μμ λλ€. NumPy μ€νμΌμ μ μνλ κΉ¨λνκ³ μ½κΈ° μ¬μ°λ©° λ§€μ° λΉ λ₯Έ 벑ν°νλ μ½λλ₯Ό κ°λ₯νκ² νλ μμ§μ λλ€.
μΌμΉνμ§ μλ λ°°μ΄μμ μλνλ κΈ°λ³Έ κ°λ λΆν° νΈνμ±μ κ΄λ¦¬νλ μ격ν κ·μΉ, `np.newaxis` λ° `reshape`λ₯Ό μ¬μ©ν λͺ¨μ μ‘°μμ μ€μ μκΉμ§ μ΄ν΄λ³΄μμ΅λλ€. μ΄λ¬ν μμΉμ΄ μ κ·ν λ° κ±°λ¦¬ κ³μ°κ³Ό κ°μ μ€μ λ°μ΄ν° κ³Όν μμ μ μ΄λ»κ² μ μ©λλμ§ νμΈνμΌλ©° κΈ°μ‘΄ 루νμ λΉν΄ μμ²λ μ±λ₯ μ΄μ μ μ μ¦νμ΅λλ€.
μμλ³ μ¬κ³ μμ μ 체 λ°°μ΄ μ°μ°μΌλ‘ μ΄λνλ©΄ NumPyμ μ§μ ν νμ λ°νν μ μμ΅λλ€. λΈλ‘λμΊμ€ν μ μμ©νκ³ λͺ¨μ μΈ‘λ©΄μμ μκ°νλ©΄ λμ± ν¨μ¨μ μ΄κ³ μ λ¬Έμ μ΄λ©° κ°λ ₯ν κ³Όν λ° λ°μ΄ν° κΈ°λ° μμ© νλ‘κ·Έλ¨μ PythonμΌλ‘ μμ±ν μ μμ΅λλ€.